package com.malou.client.ventas.modeloprenda;


import java.util.List;

import com.extjs.gxt.ui.client.data.BaseFilterPagingLoadConfig;
import com.extjs.gxt.ui.client.data.BaseListLoader;
import com.extjs.gxt.ui.client.data.BasePagingLoadConfig;
import com.extjs.gxt.ui.client.data.BasePagingLoader;
import com.extjs.gxt.ui.client.data.BeanModel;
import com.extjs.gxt.ui.client.data.BeanModelReader;
import com.extjs.gxt.ui.client.data.FilterPagingLoadConfig;
import com.extjs.gxt.ui.client.data.ListLoadResult;
import com.extjs.gxt.ui.client.data.ListLoader;
import com.extjs.gxt.ui.client.data.LoadEvent;
import com.extjs.gxt.ui.client.data.Loader;
import com.extjs.gxt.ui.client.data.ModelData;
import com.extjs.gxt.ui.client.data.PagingLoadResult;
import com.extjs.gxt.ui.client.data.PagingLoader;
import com.extjs.gxt.ui.client.data.RpcProxy;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.malou.client.MalouConstants;
import com.malou.client.MalouMessages;
import com.malou.client.graficosestadisticos.GPrendaVendidaxFechaPanel;
import com.malou.client.graficosestadisticos.PrendaVendidaxFechaPanel;
import com.malou.client.util.MensajeData;
import com.malou.client.util.Utilities;
import com.malou.client.ventas.movimiento.entrada.MovimientoEntradaDialog;
import com.malou.client.ventas.movimiento.salida.MovimientoSalidaDialog;
import com.malou.client.ventas.separacion.SeparacionDialog;
import com.malou.client.ventas.tipoprendas.TipoPrenda;
import com.malou.client.ventas.venta.VentaDialog;

public class ModeloPrendas {
	private static ModeloPrendaServiceAsync mps = GWT.create(ModeloPrendaService.class);
	private static MalouConstants constants = GWT.create(MalouConstants.class);
	private static MalouMessages messages = GWT.create(MalouMessages.class);
	private static Integer modeloprenda_id;
	public static PagingLoader<PagingLoadResult<ModelData>> loaderAutocomplete;
	public static PagingLoader<PagingLoadResult<ModelData>> loaderPrenda;
	public static ListStore<BeanModel> storeAutocomplete;
	public static ListStore<BeanModel> storePrenda;
	public static ModeloPrendaDialog modeloPrendaDialog;
	
	public static ListStore<BeanModel> storeTipoPrenda;
	public static ListLoader<ListLoadResult<ModelData>> loaderTipoPrenda;
	
	public static VentaDialog ventaDialog;
	public static SeparacionDialog separacionDialog;
	public static MovimientoEntradaDialog movimientoEntradaDialog;
	public static MovimientoSalidaDialog movimientoSalidaDialog;
	
	public static PrendaVendidaxFechaPanel prendaVendida;
	public static GPrendaVendidaxFechaPanel GprendaVendida;
	
	
	public static void getPaginate() {
		
		RpcProxy<PagingLoadResult<ModeloPrenda>> proxy = new RpcProxy<PagingLoadResult<ModeloPrenda>>() {

			@Override
			protected void load(Object loadConfig,
			      AsyncCallback<PagingLoadResult<ModeloPrenda>> callback) {
				mps.paginateModeloPrenda((FilterPagingLoadConfig) loadConfig, callback);  
				
			}  
	      
	    };
	
	    loaderPrenda = new BasePagingLoader<PagingLoadResult<ModelData>>(proxy, new BeanModelReader()){  
	        @Override  
	        protected Object newLoadConfig() {  
	          BasePagingLoadConfig config = new BaseFilterPagingLoadConfig();  
	          return config;  
	        }  
	    
	      };  
        loaderPrenda.setRemoteSort(true);
        /*loaderPrenda.addLoadListener(new LoadListener(){
        	public void loaderLoad(LoadEvent le) {
        		if(cometClient != null)
        			cometClient.stop();
        		escuchar();
        	}
        });*/
      
        storePrenda = new ListStore<BeanModel>(loaderPrenda);        
        
	}
	
	public static void save(ModeloPrenda mp) {
		modeloprenda_id = mp.getId();
		
		mps.save(mp, new AsyncCallback<MensajeData>() {

			@Override
			public void onFailure(Throwable caught) {				
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);	
				storePrenda.rejectChanges();
			}

			@Override
			public void onSuccess(MensajeData data) {
				if (data.guardado) {
					modeloPrendaDialog.hide();
					if(modeloprenda_id != null){
						storePrenda.commitChanges();
					}else
						loaderPrenda.load(0, Utilities.itemsPerPage);
					
				}
				 else {
					 modeloPrendaDialog.status.hide();
					 modeloPrendaDialog.getButtonBar().enable();
					 storePrenda.rejectChanges();
					 String msg;
					 if(data.errorTipo == 1)
						 msg = constants.modeloPrendaNoTieneSerie();					 
					 else if(data.errorTipo == 2)
						 msg = constants.modeloPrendaYaExiste();
					 else if(data.errorTipo == 3)
						 msg = constants.modeloPrendaCodigoYaExiste();
					 else if(data.errorTipo == 4)
						 msg = messages.modeloPrendaCodigoLongitud(data.parametro);
					 else
						 msg = constants.modeloPrendaNoGuardado();
					 MessageBox.alert(constants.sistemaMarcocruzado(), msg, null);
				}						
			}
			
		});
	}
	
	public static void delete(Integer id) {
		  
		  mps.delete(id, new AsyncCallback<MensajeData>() {

				@Override
				public void onFailure(Throwable caught) {					
					MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);					
				}

				@Override
				public void onSuccess(MensajeData data) {
					if (data.guardado) {					
						Integer offset =loaderPrenda.getOffset();
						loaderPrenda.load(offset, Utilities.itemsPerPage);						
					}
					 else {
						 //clienteDialog.status.hide();
						 //clienteDialog.getButtonBar().enable();					 
						 MessageBox.alert(constants.sistemaMarcocruzado(), constants.modeloPrendaNoEliminado(), null);
					}						
				}
				
			});
	  }
	
	public static void deleteAll(String ids) {
		  
		  mps.deleteAll(ids, new AsyncCallback<MensajeData>() {

				@Override
				public void onFailure(Throwable caught) {					
					MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);					
				}

				@Override
				public void onSuccess(MensajeData data) {
					if (data.guardado) {					
						Integer offset =loaderPrenda.getOffset();
						loaderPrenda.load(offset, Utilities.itemsPerPage);						
					}
					 else {
						 //clienteDialog.status.hide();
						 //clienteDialog.getButtonBar().enable();					 
						 MessageBox.alert(constants.sistemaMarcocruzado(), constants.modeloPrendaNoEliminado(), null);
					}						
				}
				
			});
	  }
	
	public static void getComboTipoPrendas(){
		RpcProxy<List<TipoPrenda>> proxy = new RpcProxy<List<TipoPrenda>>() {

			@Override
			protected void load(Object loadConfig,AsyncCallback<List<TipoPrenda>> callback) {				
				mps.getTipoPrenda(callback);
			}		      
			
	    };
	    
	    loaderTipoPrenda= new BaseListLoader<ListLoadResult<ModelData>>(proxy, new BeanModelReader());
	    
	    storeTipoPrenda = new ListStore<BeanModel>(loaderTipoPrenda);
	}
	
	public static void autoComplete() {		
		RpcProxy<PagingLoadResult<ModeloPrenda>> proxy = new RpcProxy<PagingLoadResult<ModeloPrenda>>() {
			@Override
			protected void load(Object loadConfig,
			      AsyncCallback<PagingLoadResult<ModeloPrenda>> callback) {
				mps.paginateModeloPrenda((BasePagingLoadConfig) loadConfig, callback);  				
			}	      
	    };	
	    loaderAutocomplete = new BasePagingLoader<PagingLoadResult<ModelData>>(proxy, new BeanModelReader());	      
        loaderAutocomplete.setRemoteSort(true);        
        loaderAutocomplete.addListener(Loader.BeforeLoad, new Listener<LoadEvent>() {  
		      public void handleEvent(LoadEvent be) {  
		        be.<ModelData> getConfig().set("start", be.<ModelData> getConfig().get("offset"));  
		      }  
		    });      
        storeAutocomplete = new ListStore<BeanModel>(loaderAutocomplete);
	}
	
	
	public static void getPrenda(String codigo) {		
		ventaDialog.prenda.setRawValue(constants.cargando());
		
		mps.getPrenda(codigo, new AsyncCallback<ModeloPrenda>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
			}

			@Override
			public void onSuccess(ModeloPrenda result) {
				if(result != null){
					ventaDialog.prenda_id.setValue(result.getId().toString());
					ventaDialog.codigo.setValue(result.getCodigo());					
					ventaDialog.prenda.setRawValue(result.getNombre());
					
					ventaDialog.precioxmenor = result.getPrecioventa();
					ventaDialog.precioxmayor = result.getPreciopormayor();
					
					if(ventaDialog.isPrecioxmenor)
						ventaDialog.preciounitario.setValue(result.getPrecioventa());
					else
						ventaDialog.preciounitario.setValue(result.getPreciopormayor());					
					
					ventaDialog.stock.setValue(result.getStock());
					ventaDialog.cantidad.focus();
					//ventaDialog.preciounitario.focus();
				}else{
					ventaDialog.prenda_id.setValue("");
					ventaDialog.prenda.setRawValue("No Existe");
				}
									
			}
			
		});
	}	
	
	public static void getPrendaSeparacion(String codigo) {		
		separacionDialog.prenda.setRawValue(constants.cargando());
		
		mps.getPrenda(codigo, new AsyncCallback<ModeloPrenda>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
			}

			@Override
			public void onSuccess(ModeloPrenda result) {
				if(result != null){
					separacionDialog.prenda_id.setValue(result.getId().toString());
					separacionDialog.codigo.setValue(result.getCodigo());					
					separacionDialog.prenda.setRawValue(result.getNombre());			
					
					
					separacionDialog.precioxmenor = result.getPrecioventa();
					separacionDialog.precioxmayor = result.getPreciopormayor();
					
					if(separacionDialog.isPrecioxmenor)
						separacionDialog.preciounitario.setValue(result.getPrecioventa());
					else
						separacionDialog.preciounitario.setValue(result.getPreciopormayor());					
					
					separacionDialog.stock.setValue(result.getStock());
					separacionDialog.cantidad.focus();
					
					separacionDialog.stock.setValue(result.getStock());
					
					//separacionDialog.preciounitario.focus();
				}else{
					separacionDialog.prenda_id.setValue("");
					separacionDialog.prenda.setRawValue("No Existe");
				}
									
			}
			
		});
	}
	
	public static void getPrendaMovimientoEntrada(String codigo) {		
		movimientoEntradaDialog.prenda.setRawValue(constants.cargando());
		
		mps.getPrenda(codigo, new AsyncCallback<ModeloPrenda>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
			}

			@Override
			public void onSuccess(ModeloPrenda result) {
				if(result != null){
					movimientoEntradaDialog.prenda_id.setValue(result.getId().toString());
					movimientoEntradaDialog.codigo.setValue(result.getCodigo());					
					movimientoEntradaDialog.prenda.setRawValue(result.getNombre());					
				}else{
					movimientoEntradaDialog.prenda_id.setValue("");
					movimientoEntradaDialog.prenda.setRawValue("No Existe");
				}									
			}
			
		});
	}
	
	public static void getPrendaMovimientoSalida(String codigo) {		
		movimientoSalidaDialog.prenda.setRawValue(constants.cargando());
		
		mps.getPrenda(codigo, new AsyncCallback<ModeloPrenda>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
			}

			@Override
			public void onSuccess(ModeloPrenda result) {
				if(result != null){
					movimientoSalidaDialog.prenda_id.setValue(result.getId().toString());
					movimientoSalidaDialog.codigo.setValue(result.getCodigo());					
					movimientoSalidaDialog.prenda.setRawValue(result.getNombre());	
					movimientoSalidaDialog.stock.setValue(result.getStock());	
				}else{
					movimientoSalidaDialog.prenda_id.setValue("");
					movimientoSalidaDialog.prenda.setRawValue("No Existe");
				}									
			}
			
		});
	}
	
	public static void actualizarStore(ModeloPrendaData data){
		//System.out.println("id: "+data.getModeloprenda_id());
		//System.out.println("stock: "+data.getStock());
		Integer mpdetalle_id;
		if(storePrenda != null)
		for(BeanModel b:storePrenda.getModels()){			
			mpdetalle_id = b.get("id");
			if(mpdetalle_id.toString().equals(data.getModeloprenda_id().toString())){				
				 storePrenda.getRecord(b).set("stock", data.getStock());
				 storePrenda.commitChanges();
			}			
		}
	}	
	
	public static void getPrendaGrafico(String codigo) {		
		prendaVendida.prenda.setRawValue(constants.cargando());
		
		mps.getPrenda(codigo, new AsyncCallback<ModeloPrenda>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
			}

			@Override
			public void onSuccess(ModeloPrenda result) {
				if(result != null){
					prendaVendida.prenda_id = Integer.parseInt(result.getId().toString());					
					prendaVendida.codigo.setValue(result.getCodigo());					
					prendaVendida.prenda.setRawValue(result.getNombre());
					
				}else{
					prendaVendida.prenda_id=null;
					prendaVendida.prenda.setRawValue("No Existe");
				}
									
			}
			
		});
	}
	
	public static void getGPrendaGrafico(String codigo) {		
		GprendaVendida.prenda.setRawValue(constants.cargando());
		
		mps.getPrenda(codigo, new AsyncCallback<ModeloPrenda>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
			}

			@Override
			public void onSuccess(ModeloPrenda result) {
				if(result != null){
					GprendaVendida.prenda_id = Integer.parseInt(result.getId().toString());					
					GprendaVendida.codigo.setValue(result.getCodigo());					
					GprendaVendida.prenda.setRawValue(result.getNombre());
					
				}else{
					GprendaVendida.prenda_id=null;
					GprendaVendida.prenda.setRawValue("No Existe");
				}
									
			}
			
		});
	}
}
